home *** CD-ROM | disk | FTP | other *** search
/ Skunkware 5 / Skunkware 5.iso / src / X11 / xarchie-2.0.9 / saveload.c < prev    next >
C/C++ Source or Header  |  1995-06-18  |  8KB  |  281 lines
  1. /*
  2.  * saveload.c : Device-independent routines for writing (ie printing),
  3.  *    saving, and restoring the browser contents.
  4.  *
  5.  * George Ferguson, ferguson@cs.rochester.edu, 23 Apr 1993.
  6.  */
  7. #include <stdio.h>
  8. #include "sysdefs.h"
  9. #include "stringdefs.h"
  10. #include "pfs.h"
  11. #include "pprot.h"
  12. #include "xtypes.h"
  13. #include "db.h"
  14. #include "query.h"
  15. #include "browser.h"
  16. #include "settings.h"
  17. #include "types.h"
  18. #include "appres.h"
  19. #include "alert.h"
  20. #include "status.h"
  21.  
  22. /*
  23.  * Functions defined here
  24.  */
  25. int save(),load(),writeToFile();
  26.  
  27. static void writeEntry(),saveEntry();
  28.  
  29. /*    -    -    -    -    -    -    -    -    */
  30. /*
  31.  * Save browser contents to FILENAME for later load.
  32.  */
  33. int
  34. save(db,filename)
  35. DbEntry *db;
  36. char *filename;
  37. {
  38.     FILE *fp;
  39.     DbEntry *hostp,*locp,*filep;
  40.  
  41.     if ((fp=fopen(filename,"w")) == NULL) {
  42.     alert1("Can't open %s for writing",filename);
  43.     return(0);
  44.     }
  45.     status1("Saving to %s...",filename);
  46.     /* Save the settinsg first */
  47.     fprintf(fp,"archieHost: %s\n",appResources.archieHost);
  48.     fprintf(fp,"searchType: %s\n",searchTypeToString(appResources.searchType));
  49.     fprintf(fp,"sortType: %s\n",sortTypeToString(appResources.sortType));
  50.     fprintf(fp,"niceLevel: %d\n",appResources.niceLevel);
  51.     fprintf(fp,"maxHits: %d\n",appResources.maxHits);
  52.     fprintf(fp,"timeout: %d\n",appResources.timeout);
  53.     fprintf(fp,"retries: %d\n",appResources.retries);
  54.     /* Now dump the browser */
  55.     for (hostp=db->entries; hostp != NULL; hostp = hostp->next)
  56.     for (locp=hostp->entries; locp != NULL; locp = locp->next)
  57.         for (filep=locp->entries; filep != NULL; filep=filep->next)
  58.         saveEntry(fp,filep);
  59.     fclose(fp);
  60.     status0("Ready");
  61.     return(1);
  62. }
  63.  
  64. static void
  65. saveEntry(fp,dbp)
  66. FILE *fp;
  67. DbEntry *dbp;
  68. {
  69.     VLINK vl;
  70.     DbEntry *entry;
  71.  
  72.     /* Sanity check */
  73.     if ((vl=dbp->vlink) == NULL) {
  74.     fprintf(stderr,"NULL vlink to save()\n");
  75.     return;
  76.     }
  77.     /* Save the vlink info */
  78.     fprintf(fp,"LINK %c %s '%s' %s %s %s %s %d %d ", vl->linktype,
  79.         vl->type, vl->name, vl->hosttype, vl->host, 
  80.         vl->nametype, vl->filename, vl->version,
  81.         vl->f_magic_no);
  82.     /* And the relevant attributes */
  83.     fprintf(fp,"%d ",dbp->size);
  84.     fprintf(fp,"%s ",dbp->modes);
  85.     fprintf(fp,"%s",dbp->gt_date);
  86. #ifdef undef
  87.     /* When we didn't keep gt_date (now needed for sorting), we used this: */
  88.     for (ap = vl->lattrib; ap; ap = ap->next)
  89.     if (strcmp(ap->aname,"LAST-MODIFIED") == 0)
  90.         fprintf(fp,"%s",ap->value.ascii);
  91. #endif
  92.     fprintf(fp,"\n");
  93.     /* Recursively save the sub-entries */
  94.     for (entry=dbp->entries; entry != NULL; entry=entry->next)
  95.     saveEntry(fp,entry);
  96. }
  97.  
  98. /*
  99.  * Load browser from FILENAME made by save.
  100.  */
  101. int
  102. load(db,filename)
  103. DbEntry *db;
  104. char *filename;
  105. {
  106.     FILE *fp;
  107.     char buf[256];
  108.     VLINK first_link,last_link,cur_link;
  109.     PATTRIB cur_at;
  110.     char l_linktype;
  111.     char l_name[MAX_DIR_LINESIZE];
  112.     char l_type[MAX_DIR_LINESIZE];
  113.     char l_htype[MAX_DIR_LINESIZE];
  114.     char l_host[MAX_DIR_LINESIZE];
  115.     char l_ntype[MAX_DIR_LINESIZE];
  116.     char l_fname[MAX_DIR_LINESIZE];
  117.     int    tmp;
  118.  
  119.     if ((fp=fopen(filename,"r")) == NULL) {
  120.     alert1("Can't open %s for reading",filename);
  121.     return(0);
  122.     }
  123.     status1("Loading from %s...",filename);
  124.     /* Load the settings */
  125.     if (fscanf(fp,"archieHost: %s\n",appResources.archieHost) < 1 ||
  126.     fscanf(fp,"searchType: %s\n",buf) < 1 ||
  127.     (appResources.searchType=stringToSearchType(buf)) == GfError ||
  128.     fscanf(fp,"sortType: %s\n",buf) < 1 ||
  129.     (appResources.sortType=stringToSortType(buf)) == GfError ||
  130.     fscanf(fp,"niceLevel: %d\n",&(appResources.niceLevel)) < 1 ||
  131.     fscanf(fp,"maxHits: %d\n",&(appResources.maxHits)) < 1 ||
  132.     fscanf(fp,"timeout: %d\n",&(appResources.timeout)) < 1 ||
  133.     fscanf(fp,"retries: %d\n",&(appResources.retries)) < 1) {
  134.     fclose(fp);
  135.     alert1("Error in header of file \"%s\"!",filename);
  136.     return(0);
  137.     } else {
  138.     reinitSettings();
  139.     }
  140.     /* Load the browser */
  141.     first_link = last_link = NULL;
  142.     while (!feof(fp)) {
  143.     /* Get a new vlink */
  144.     cur_link = vlalloc();
  145.     /* Read the vlink fields */
  146.     tmp = fscanf(fp,"LINK %c %s %s %s %s %s %s %d %d", &l_linktype,
  147.              l_type, l_name, l_htype, l_host, 
  148.              l_ntype, l_fname, &(cur_link->version),
  149.              &(cur_link->f_magic_no));
  150.     if (tmp != 9) {
  151.         alert1("Load error in file %s!",filename);
  152.         vlfree(cur_link);
  153.         break;
  154.     }
  155.     /* Store data in vlink */
  156.     cur_link->linktype = l_linktype;
  157.     cur_link->type = stcopyr(l_type,cur_link->type);
  158.     cur_link->name = stcopyr(unquote(l_name),cur_link->name);
  159.     cur_link->hosttype = stcopyr(l_htype,cur_link->hosttype);
  160.     cur_link->host = stcopyr(l_host,cur_link->host);
  161.     cur_link->nametype = stcopyr(l_ntype,cur_link->nametype);
  162.     cur_link->filename = stcopyr(l_fname,cur_link->filename);
  163.     /* Add vlink to chain */
  164.     if (first_link == NULL) {
  165.         last_link = first_link = cur_link;
  166.         cur_link->next = cur_link->previous = NULL;
  167.     } else {
  168.         last_link->next = cur_link;
  169.         cur_link->previous = last_link;
  170.         cur_link->next = NULL;
  171.         last_link = cur_link;
  172.     }
  173.     /* Read the attributes */
  174.     tmp = fscanf(fp,"%s %s %s\n",l_name,l_type,l_htype);
  175.     if (tmp != 3) {
  176.         alert1("Load error in file %s!",filename);
  177.         break;
  178.     }
  179.     /* Put them in the vlink's attribute list */
  180.     cur_link->lattrib = cur_at = atalloc();
  181.     cur_at->aname = stcopyr("SIZE",cur_at->aname);
  182.     cur_at->avtype = stcopyr("ASCII",cur_at->avtype);
  183.     cur_at->value.ascii = stcopyr(l_name,cur_at->value.ascii);
  184.     cur_at->next = atalloc();
  185.     cur_at->next->previous = cur_at;
  186.     cur_at = cur_at->next;
  187.     cur_at->aname = stcopyr("UNIX-MODES",cur_at->aname);
  188.     cur_at->avtype = stcopyr("ASCII",cur_at->avtype);
  189.     cur_at->value.ascii = stcopyr(l_type,cur_at->value.ascii);
  190.     cur_at->next = atalloc();
  191.     cur_at->next->previous = cur_at;
  192.     cur_at = cur_at->next;
  193.     cur_at->aname = stcopyr("LAST-MODIFIED",cur_at->aname);
  194.     cur_at->avtype = stcopyr("ASCII",cur_at->avtype);
  195.     cur_at->value.ascii = stcopyr(l_htype,cur_at->value.ascii);
  196.     }
  197.     fclose(fp);
  198.     if (first_link == NULL) {
  199.     status0("No entries loaded!");
  200.     return(0);
  201.     }
  202.     status0("Parsing...");
  203.     resetBrowser();
  204.     clearEntries(db);
  205.     tmp = parseArchieQueryResults(db,first_link,NULL);
  206.     displayEntries(db,0);
  207.     status2("Loaded %d entries from \"%s\"",(char *)tmp,filename);
  208.     return(1);
  209. }
  210.  
  211. /*    -    -    -    -    -    -    -    -    */
  212. /*
  213.  * Write browser contents to FILENAME. If ONELINE is True, each entry gets
  214.  *    whole line.
  215.  */
  216. int
  217. writeToFile(db,filename,oneline)
  218. DbEntry *db;
  219. char *filename;
  220. int oneline;
  221. {
  222.     FILE *fp;
  223.     DbEntry *hostp,*locp,*filep;
  224.     char *prefix;
  225.  
  226.     if ((fp=fopen(filename,"w")) == NULL) {
  227.     alert1("Can't open %s for writing",filename);
  228.     return(0);
  229.     }
  230.     status1("Writing to %s...",filename);
  231.     if (oneline) {
  232.     for (hostp=db->entries; hostp != NULL; hostp = hostp->next)
  233.         for (locp=hostp->entries; locp != NULL; locp = locp->next)
  234.         for (filep=locp->entries; filep != NULL; filep=filep->next) {
  235.             prefix = malloc(strlen(hostp->name)+strlen(locp->name)+3);
  236.             sprintf(prefix,"%s:%s/",hostp->name,locp->name);
  237.             writeEntry(fp,filep,oneline,prefix);
  238.             free(prefix);
  239.         }
  240.     } else {
  241.     for (hostp=db->entries; hostp != NULL; hostp = hostp->next) {
  242.         fprintf(fp,"%s\n",hostp->name);
  243.         for (locp=hostp->entries; locp != NULL; locp = locp->next) {
  244.         fprintf(fp,"\t%s\n",locp->name);
  245.         for (filep=locp->entries; filep != NULL; filep=filep->next)
  246.             writeEntry(fp,filep,oneline,"");
  247.         }
  248.     }
  249.     }
  250.     fclose(fp);
  251.     status0("Ready");
  252.     return(1);
  253. }
  254.  
  255. static void
  256. writeEntry(fp,filep,oneline,prefix)
  257. FILE *fp;
  258. DbEntry *filep;
  259. int oneline;
  260. char *prefix;
  261. {
  262.     DbEntry *entry;
  263.     char *newprefix;
  264.  
  265.     /* Write this entry */
  266.     if (oneline) {
  267.     fprintf(fp,"%s %10d  %12s  %s%s\n",
  268.         filep->modes,filep->size,filep->date,prefix,filep->name);
  269.     } else {
  270.     fprintf(fp,"\t\t%s %10d  %12s  %s%s\n",
  271.         filep->modes,filep->size,filep->date,prefix,filep->name);
  272.     }
  273.     /* Add this entry to the prefix */
  274.     newprefix = malloc(strlen(prefix)+strlen(filep->name)+2);
  275.     sprintf(newprefix,"%s%s/",prefix,filep->name);
  276.     /* Recursively write the sub-entries */
  277.     for (entry=filep->entries; entry != NULL; entry=entry->next)
  278.     writeEntry(fp,entry,oneline,newprefix);
  279.     free(newprefix);
  280. }
  281.